home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / tcp_ip / gp / 7plsrc.lzh / UTILS.C < prev   
C/C++ Source or Header  |  1991-12-22  |  11KB  |  607 lines
  1. #include "7plus.h"
  2. #include "globals.h"
  3.  
  4. /*
  5. *** get a line from file. don't care about type of line separator.
  6. ***
  7. ***
  8. ***
  9.  */
  10.  
  11. char *my_fgets (char *string, register n, FILE *rein)
  12. {
  13.   register in, i;
  14.  
  15.   while ((in = fgetc (rein)) != EOF)
  16.   {
  17.     if (in == 0x0d || in == 0x0a)
  18.       continue;
  19.     else
  20.       break;
  21.   }
  22.   if (feof (rein))
  23.     return (NULL);
  24.  
  25.   string[0] = (char) in;
  26.   i = 1;
  27.   while ((in = fgetc (rein)) != EOF)
  28.   {
  29.     if (in == 0x0d || in == 0x0a)
  30.       in = 0x0a;
  31.     string[i++] = (char) in;
  32.     if (i == n || in == 0x0a)
  33.       break;
  34.   }
  35.   string[i] = EOS;
  36.   return (string);
  37. } 
  38.  
  39. /*
  40. *** Get crc and line number from code line.
  41. ***
  42. ***
  43.  */
  44.  
  45. void crc_n_lnum (uint *crc, int *linenumber, char *line)
  46. {
  47.   register ulong cs;
  48.  
  49.   cs = 0xb640L * decode[(byte)line[66]] +
  50.        0xd8L   * decode[(byte)line[65]] +
  51.                  decode[(byte)line[64]];
  52.  
  53.   *linenumber = (int) (cs >> 14);   /* upper 9 bits are the line number */
  54.   *crc = (uint) (cs & 0x3fffL);     /* lower 14 bits are the CRC */
  55. }
  56.  
  57. /*
  58. *** Get crc2 from code line.
  59. ***
  60. ***
  61.  */
  62.  
  63. void crc2 (uint *crc, char *line)
  64. {
  65.  
  66.   *crc = 0xd8 * decode[(byte)line[68]] +
  67.                 decode[(byte)line[67]];
  68. }
  69.  
  70. /*
  71. *** Whip up 2nd CRC
  72. ***
  73. ***
  74.  */
  75. void add_crc2 (char *line)
  76. {
  77.   register uint crc;
  78.   register int i;
  79.  
  80.   /* Whip up 2nd CRC */
  81.   crc = 0;
  82.   for (i=66;i>-1;i--)
  83.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte) line[i]);
  84.   crc &= 0x7fff;
  85.  
  86.   i = 67;
  87.   line[i++] = code[crc % 0xd8];
  88.   line[i++] = code[crc / 0xd8];
  89.   line[i] = EOS;
  90. }
  91.  
  92. /*
  93. *** mini-crc for header. safe enough...
  94. ***
  95. ***
  96.  */
  97. int mcrc (char *line, int flag)
  98. {
  99.   register int i, j;
  100.   register uint crc;
  101.   char test[3], *p;
  102.  
  103.   sprintf (test, "\xb0\xb1");
  104.  
  105.   if ((p = strstr (line, test)) == NULL)
  106.     return (0);
  107.  
  108.   j = (int) (p - line) + 4;
  109.  
  110.   for (i=crc=0; i<j; i++)
  111.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  112.   crc %= 216;
  113.   if (!flag)
  114.   {
  115.     if (crc == (uint) decode[(byte)line[j]])
  116.       return (1);
  117.     else
  118.       return (0);
  119.   }
  120.   else
  121.     line[j] = code[(byte)crc];
  122.  
  123.   return (crc);
  124. }
  125.  
  126. /*
  127. *** read a file, search for s1, calculate CRC until s2 is found.
  128. *** flag == 1: compare calculated an read CRC.
  129. *** flag == 0: append CRC to file.
  130.  */
  131. int crc_file (char *file, char *s1, char *s2, int flag)
  132. {
  133.   char line[81];
  134.   uint crc, cs;
  135.   int i, j, k;
  136.   FILE *in;
  137.  
  138.   crc = cs = 0;
  139.  
  140.   if ((in = fopen (file, OPEN_READ_TEXT)) == NULL)
  141.   {
  142.     printf (cant, file);
  143.     exit (2);
  144.   }
  145.  
  146.   i = (int) strlen (s1);
  147.   k = (int) strlen (s2);
  148.  
  149.   j = 1;
  150.  
  151.   do
  152.   {
  153.     if (my_fgets (line, 80, in) == NULL)
  154.       break;
  155.  
  156.     j = strncmp (line, s1, i);
  157.   }
  158.   while (j);
  159.  
  160.   if (j)
  161.   {
  162.     printf ("\nStart '%s' not found.\n", s1);
  163.     exit (0);
  164.   }
  165.  
  166.   j = 0;
  167.  
  168.   do
  169.   {
  170.     for (i=0;i!=(int)strlen(line);i++)
  171.       crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  172.  
  173.     j = strncmp (line, s2, k);
  174.  
  175.     if (!j)
  176.       continue;
  177.  
  178.     if (my_fgets (line, 80, in) == NULL)
  179.       break;
  180.   }
  181.   while (j);
  182.  
  183.  
  184.   if (j)
  185.   {
  186.     printf ("\nEnd '%s' not found.\n", s2);
  187.     exit (0);
  188.   }
  189.  
  190.   my_fgets (line, 80, in);
  191.  
  192.   fclose (in);
  193.  
  194.   /* evaluate CRC */
  195.   if (flag)
  196.   {
  197.     if (!line || strncmp ("CRC ", line, 4))
  198.     {
  199.       printf ("\n'%s': no CRC found.\n(File may be corrupted or from version \
  200. earlier than 7PLUS v1.5)\n", file);
  201.       return (2);
  202.     }
  203.     cs = get_hex (line+4);
  204.     if (cs == crc)
  205.       return (0);
  206.     else
  207.     {
  208.       printf ("\007'%s' is corrupted. Break.\n", file);
  209.       return (1);
  210.     }
  211.   }
  212.   else
  213.   { /* append CRC to file */
  214.     in = fopen (file, OPEN_APPEND_TEXT);
  215.     fprintf (in, "CRC %04X%s", crc, delimit);
  216.     fclose (in);
  217.   }
  218.   return (0);
  219. }
  220.  
  221. /*
  222. ***
  223. *** Write a byte to file.
  224. ***
  225.  */
  226.  
  227. int my_putc (int outchar, FILE *out)
  228. {
  229.   register x;
  230.  
  231.   if ((x = putc ((char) outchar, out)) == EOF)
  232.   {
  233.     printf ("\007\nWrite error! Can't continue.\n");
  234.     exit (1);
  235.   }
  236.   return (x);
  237. }
  238.  
  239. /*
  240. ***
  241. ***
  242. ***
  243.  */
  244. void kill_dest (FILE *in, FILE *out, char *name)
  245. {
  246.     if (out)
  247.       fclose (out);
  248.     if (in)
  249.       fclose (in);
  250.     if (*name)
  251.       unlink (name);
  252. }
  253.  
  254. /*
  255. ***
  256. ***  test if a file exists at all
  257. ***
  258.  */
  259.  
  260. int test_exist (char *filename)
  261. {
  262.   FILE *rein = NULL;
  263.  
  264.   if ((rein = fopen (filename, OPEN_READ_TEXT)) != NULL)
  265.   {
  266.     fclose (rein);
  267.     return (0);
  268.   }
  269.   return (1);
  270. }
  271.  
  272.  
  273. /*
  274. ***  test if outputfile already exists. prompt for overwrite or
  275. ***  new name.
  276. ***
  277. ***
  278.  */
  279.  
  280. void test_file (FILE *rein, char *destnam, int flag, int namsize)
  281. {
  282.    FILE *raus;
  283.    char compare[30], no[] = NO, yes[] = YES;
  284.    int i;
  285.    
  286.    if (noquery)
  287.      return;
  288.  
  289.    sprintf (compare, "%%%d[^\n]", namsize);
  290.  
  291.    /* Loop as long as file can be opened. */
  292.    while ((raus = fopen (destnam, OPEN_READ_BINARY)) != NULL)
  293.    {
  294.      printf ("\007\nOutputfile '%s' already exists, overwrite? [y/n] ", destnam);
  295.      do
  296.      {
  297.        i = getch ();
  298.        if (i == 'n' || i == 'N')
  299.        {
  300.          if (flag)
  301.          {
  302.            printf ("%s\n\nEnter new name (max %d chars)\n", no, namsize);
  303.            printf ("or simply press ENTER to break : ");
  304.            fflush (stdin);
  305.            if (namsize == 12)
  306.              strlwr (destnam);
  307.            scanf (compare, destnam);
  308.            fflush (stdin);
  309.          }
  310.          else
  311.            *destnam = EOS;
  312.          if (!strlen (destnam))
  313.          {
  314.            if (!flag)
  315.              printf ("%s\n", no);
  316.            printf ("Break.\n");
  317.            fclose (rein);
  318.            exit (10);
  319.          }
  320.          i = 0xff; /* indicate, that new name has been specified */
  321.        }
  322.      }
  323.      while (i != 'y' && i != 'Y' && i != 0xff);
  324.      if (i != 0xff)
  325.        printf ("%s\n", yes);
  326.      printf ("\n");
  327.      fclose (raus);
  328.      if (i != 0xff)
  329.        break;
  330.    }
  331. }
  332.  
  333.  
  334. /*
  335. *** initialize decoding table
  336. ***
  337. ***
  338. ***
  339.  */
  340.  
  341. void init_decodetab (void)
  342. {
  343.   register i;
  344.   register byte j;
  345.  
  346.   for (i = 0; i < 256; i++)
  347.     decode[i] = 255;
  348.  
  349.   j = 0;
  350.   for (i = 0x21; i < 0x2a; i++)
  351.     decode[i] = j++;
  352.  
  353.   for (i = 0x2b; i < 0x7f; i++)
  354.     decode[i] = j++;
  355.  
  356.   for (i = 0x80; i < 0x91; i++)
  357.     decode[i] = j++;
  358.  
  359.   decode[0x92] = j++;
  360.  
  361.   for (i = 0x94; i < 0xfd; i++)
  362.     decode[i] = j++;
  363. }
  364.  
  365. /*
  366. *** initialize encoding table
  367. ***
  368. ***
  369. ***
  370.  */
  371.  
  372. void init_codetab (void)
  373. {
  374.   register byte i, j;
  375.  
  376.   j = 0;
  377.  
  378.   for (i = 0x21; i < 0x2a; i++, j++)
  379.     code[j] = i;
  380.  
  381.   for (i = 0x2b; i < 0x7f; i++, j++)
  382.     code[j] = i;
  383.  
  384.   for (i = 0x80; i < 0x91; i++, j++)
  385.     code[j] = i;
  386.  
  387.   code[j++] = 146;
  388.  
  389.   for (i = 0x94; i < 0xfd; i++, j++)
  390.     code[j] = i;
  391. }
  392.  
  393. /*
  394. *** Tnx to DC4OX.
  395. ***
  396. *** calculate CRC-table
  397. ***
  398.  */
  399.  
  400. void init_crctab (void)
  401. {
  402.   uint m, n, r, mask;
  403.  
  404.   static uint bitrmdrs[] = { 0x9188,0x48C4,0x2462,0x1231,
  405.                              0x8108,0x4084,0x2042,0x1021 };
  406.  
  407.   for (n = 0; n < 256; ++n)
  408.   {
  409.     for (mask = 0x0080, r = 0, m = 0; m < 8; ++m, mask >>= 1)
  410.       if (n & mask)
  411.         r = bitrmdrs[m] ^ r;
  412.     crctab[n] = r;
  413.   }
  414. }
  415.  
  416. /*
  417. *** Create a MSDOS/ATARI compatible filename.
  418. ***
  419. ***
  420. ***
  421.  */
  422.  
  423. void build_DOS_name (char *name)
  424. {
  425.   char tmp[MAXFNAME];
  426.   register i, j;
  427.  
  428.   i = j = 0;
  429.  
  430.   strcpy (tmp, name);
  431.   strlwr (tmp);
  432.  
  433.   if (*tmp)
  434.   {
  435.     do
  436.     {
  437.       tmp[i] &= 127;
  438.       if (strchr (" <>=,;:*?&[]()/.\\\"~+@", tmp[i]) == NULL)
  439.         name[j++] = tmp[i];
  440.     }
  441.     while (tmp[++i]);
  442.  
  443.     name[j] = EOS;
  444.   }
  445. }
  446.  
  447. /*
  448. *** get_hex: some compilers have real big trouble when reading hex values from
  449. ***          a file with fscanf() that have leading zeros! e.g. 00A will be
  450. ***          read as two separate values (0 and A)! grr!!
  451. ***          get_hex skips all leading zeros to eliminate the problem.
  452. ***
  453.  */
  454. uint get_hex (char *hex)
  455. {
  456.   register i = 0;
  457.   uint   ret = 0;
  458.  
  459.   while (hex[i] == '0')
  460.     i++;
  461.   sscanf(hex+i, "%x", &ret);
  462.   return (ret);
  463. }
  464.  
  465.  
  466. #ifdef _FNSPLIT
  467. /*
  468. ***       filenamesplit
  469. ***       (by DL1MEN, taken from SP-ST, modified for portability)
  470. ***
  471. ***       split filename up into drive, path, name and extension.
  472. ***
  473.  */
  474.  
  475. void fnsplit(char *pth, char *dr, char *pa, char *fn, char *ft)
  476. {
  477.    char drv[MAXDRIVE], pat[MAXDIR], fna[MAXFILE], fty[MAXEXT], tmp[MAXPATH];
  478.    char *p;
  479.  
  480.    strcpy(tmp,pth);
  481.   
  482.    if ((p = strchr(tmp,':')) != NULL)
  483.    {
  484.      *p++ = EOS;
  485.      strcpy(drv,tmp);
  486.    }
  487.    else
  488.    {
  489.      p = tmp;
  490.      drv[0] = EOS;
  491.    }
  492.    if ((pth = strrchr(p, PATHCHAR)) != NULL)
  493.    {
  494.      *pth++ = EOS;
  495.      strcpy(pat,p);
  496.    }
  497.    else
  498.    {
  499.      pth = p;
  500.      pat[0] = EOS;
  501.    }
  502.    if ((p = strchr(pth,'.')) != NULL)
  503.    {
  504.      strcpy(fty,p);
  505.      fty[MAXEXT-1] = EOS;
  506.      *p = EOS;
  507.    }
  508.    else
  509.      fty[0] = EOS;
  510.  
  511.    strcpy(fna,pth);
  512.    fna[MAXFILE-1] = EOS;
  513.  
  514.    if (dr)
  515.    {
  516.      strcpy(dr,drv);
  517.      if (drv[0])
  518.        strcat(dr,":");
  519.    }
  520.    if (pa)
  521.    {
  522.      strcpy(pa,pat);
  523.      if (pat[0])
  524.        strcat(pa, PATHSEP);
  525.    }
  526.    if (fn)
  527.      strcpy(fn,fna);
  528.    if (ft)
  529.      strcpy(ft,fty);
  530. }
  531. #endif /** _FNSPLIT **/
  532.  
  533. #ifdef _ICMP
  534. /* The following functions are unfortunately not avialable on Aztec 5.0b,
  535.    because it sticks closely to the ANSI_C standard. You may also have
  536.    to include these functions, if compiling on other ANSI_C compilers.*/
  537.  
  538. /*
  539. *** strupr - convert string to upper case.
  540. ***
  541. ***
  542.  */
  543. char *strupr (char *string)
  544. {
  545.   char *strcnvt (char *string, int flag);
  546.  
  547.   return (strcnvt (string, 1));
  548. }
  549.  
  550. /*
  551. *** strlwr - convert string to lower case.
  552. ***
  553. ***
  554.  */
  555. char *strlwr (char *string)
  556. {
  557.   char *strcnvt (char *string, int flag);
  558.  
  559.   return (strcnvt (string, 0));
  560. }
  561.  
  562. /*
  563. *** strcnvt - convert string to upper (flag == 1) or lower (flag == 0) case.
  564. ***
  565. ***
  566.  */
  567. char *strcnvt (char *string, int flag)
  568. {
  569.   register i = 0;
  570.  
  571.   while (string[i])
  572.   {  
  573.     string[i] = (flag)?toupper (string[i]):tolower (string[i]);
  574.     i++;
  575.   }
  576.  
  577.   return (string);
  578. }
  579.  
  580. /*
  581. *** stricmp - same as strcmp(), but ignores case.
  582. *** s1 and s2 are not modified.
  583. ***
  584.  */
  585. int stricmp (char *s1, char *s2)
  586. {
  587.   return (strnicmp (s1, s2, (size_t) 80));
  588. }
  589.  
  590. /*
  591. *** strnicmp - same as strncmp(), but ignores case.
  592. *** s1 and s2 are not modified.
  593. ***
  594.  */
  595. int strnicmp (char *s1, char *s2, int n)
  596. {
  597.   char _s1[81], _s2[81];
  598.  
  599.   strncpy (_s1, s1, 80);
  600.   strncpy (_s2, s2, 80);
  601.   strupr (_s1);
  602.   strupr (_s2);
  603.  
  604.   return (strncmp (_s1, _s2, n));
  605. }
  606. #endif /** _ICMP **/
  607.